{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorFlow Tutorial\n",
    "\n",
    "Welcome to this week's programming assignment. Until now, you've always used numpy to build neural networks. Now we will step you through a deep learning framework that will allow you to build neural networks more easily. Machine learning frameworks like TensorFlow, PaddlePaddle, Torch, Caffe, Keras, and many others can speed up your machine learning development significantly. All of these frameworks also have a lot of documentation, which you should feel free to read. In this assignment, you will learn to do the following in TensorFlow: \n",
    "\n",
    "- Initialize variables\n",
    "- Start your own session\n",
    "- Train algorithms \n",
    "- Implement a Neural Network\n",
    "\n",
    "Programing frameworks can not only shorten your coding time, but sometimes also perform optimizations that speed up your code. \n",
    "\n",
    "## 1 - Exploring the Tensorflow Library\n",
    "\n",
    "To start, you will import the library:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.framework import ops\n",
    "from tf_utils import load_dataset, random_mini_batches, convert_to_one_hot, predict\n",
    "\n",
    "%matplotlib inline\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have imported the library, we will walk you through its different applications. You will start with an example, where we compute for you the loss of one training example. \n",
    "$$loss = \\mathcal{L}(\\hat{y}, y) = (\\hat y^{(i)} - y^{(i)})^2 \\tag{1}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From D:\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "y_hat = tf.constant(36, name='y_hat')            # Define y_hat constant. Set to 36.\n",
    "y = tf.constant(39, name='y')                    # Define y. Set to 39\n",
    "\n",
    "loss = tf.Variable((y - y_hat)**2, name='loss')  # Create a variable for the loss\n",
    "\n",
    "init = tf.global_variables_initializer()         # When init is run later (session.run(init)),\n",
    "                                                 # the loss variable will be initialized and ready to be computed\n",
    "with tf.Session() as session:                    # Create a session and print the output\n",
    "    session.run(init)                            # Initializes the variables\n",
    "    print(session.run(loss))                     # Prints the loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Writing and running programs in TensorFlow has the following steps:\n",
    "\n",
    "1. Create Tensors (variables) that are not yet executed/evaluated. \n",
    "2. Write operations between those Tensors.\n",
    "3. Initialize your Tensors. \n",
    "4. Create a Session. \n",
    "5. Run the Session. This will run the operations you'd written above. \n",
    "\n",
    "Therefore, when we created a variable for the loss, we simply defined the loss as a function of other quantities, but did not evaluate its value. To evaluate it, we had to run `init=tf.global_variables_initializer()`. That initialized the loss variable, and in the last line we were finally able to evaluate the value of `loss` and print its value.\n",
    "\n",
    "Now let us look at an easy example. Run the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"Mul:0\", shape=(), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "a = tf.constant(2)\n",
    "b = tf.constant(10)\n",
    "c = tf.multiply(a,b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, you will not see 20! You got a tensor saying that the result is a tensor that does not have the shape attribute, and is of type \"int32\". All you did was put in the 'computation graph', but you have not run this computation yet. In order to actually multiply the two numbers, you will have to create a session and run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "sess = tf.Session()\n",
    "print(sess.run(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! To summarize, **remember to initialize your variables, create a session and run the operations inside the session**. \n",
    "\n",
    "Next, you'll also have to know about placeholders. A placeholder is an object whose value you can specify only later. \n",
    "To specify values for a placeholder, you can pass in values by using a \"feed dictionary\" (`feed_dict` variable). Below, we created a placeholder for x. This allows us to pass in a number later when we run the session. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# Change the value of x in the feed_dict\n",
    "\n",
    "x = tf.placeholder(tf.int64, name = 'x')\n",
    "print(sess.run(2 * x, feed_dict = {x: 3}))\n",
    "sess.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you first defined `x` you did not have to specify a value for it. A placeholder is simply a variable that you will assign data to only later, when running the session. We say that you **feed data** to these placeholders when running the session. \n",
    "\n",
    "Here's what's happening: When you specify the operations needed for a computation, you are telling TensorFlow how to construct a computation graph. The computation graph can have some placeholders whose values you will specify only later. Finally, when you run the session, you are telling TensorFlow to execute the computation graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 - Linear function\n",
    "\n",
    "Lets start this programming exercise by computing the following equation: $Y = WX + b$, where $W$ and $X$ are random matrices and b is a random vector. \n",
    "\n",
    "**Exercise**: Compute $WX + b$ where $W, X$, and $b$ are drawn from a random normal distribution. W is of shape (4, 3), X is (3,1) and b is (4,1). As an example, here is how you would define a constant X that has shape (3,1):\n",
    "```python\n",
    "X = tf.constant(np.random.randn(3,1), name = \"X\")\n",
    "\n",
    "```\n",
    "You might find the following functions helpful: \n",
    "- tf.matmul(..., ...) to do a matrix multiplication\n",
    "- tf.add(..., ...) to do an addition\n",
    "- np.random.randn(...) to initialize randomly\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: linear_function\n",
    "\n",
    "def linear_function():\n",
    "    \"\"\"\n",
    "    Implements a linear function: \n",
    "            Initializes W to be a random tensor of shape (4,3)\n",
    "            Initializes X to be a random tensor of shape (3,1)\n",
    "            Initializes b to be a random tensor of shape (4,1)\n",
    "    Returns: \n",
    "    result -- runs the session for Y = WX + b \n",
    "    \"\"\"\n",
    "    \n",
    "    np.random.seed(1)\n",
    "    \n",
    "    ### START CODE HERE ### (4 lines of code)\n",
    "    X = tf.constant(np.random.randn(3,1), name = \"X\")\n",
    "    W = tf.constant(np.random.randn(4,3), name = \"W\")\n",
    "    b = tf.constant(np.random.randn(4,1), name = \"b\")\n",
    "    Y = tf.add(tf.matmul(W, X), b) \n",
    "    ### END CODE HERE ### \n",
    "    \n",
    "    # Create the session using tf.Session() and run it with sess.run(...) on the variable you want to calculate\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    sess = tf.Session() \n",
    "    result = sess.run(Y)\n",
    "    ### END CODE HERE ### \n",
    "    \n",
    "    # close the session \n",
    "    sess.close()\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "result = [[-2.15657382]\n",
      " [ 2.95891446]\n",
      " [-1.08926781]\n",
      " [-0.84538042]]\n"
     ]
    }
   ],
   "source": [
    "print( \"result = \" + str(linear_function()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*** Expected Output ***: \n",
    "\n",
    "<table> \n",
    "<tr> \n",
    "<td>\n",
    "**result**\n",
    "</td>\n",
    "<td>\n",
    "[[-2.15657382]\n",
    " [ 2.95891446]\n",
    " [-1.08926781]\n",
    " [-0.84538042]]\n",
    "</td>\n",
    "</tr> \n",
    "\n",
    "</table> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 - Computing the sigmoid \n",
    "Great! You just implemented a linear function. Tensorflow offers a variety of commonly used neural network functions like `tf.sigmoid` and `tf.softmax`. For this exercise lets compute the sigmoid function of an input. \n",
    "\n",
    "You will do this exercise using a placeholder variable `x`. When running the session, you should use the feed dictionary to pass in the input `z`. In this exercise, you will have to (i) create a placeholder `x`, (ii) define the operations needed to compute the sigmoid using `tf.sigmoid`, and then (iii) run the session. \n",
    "\n",
    "** Exercise **: Implement the sigmoid function below. You should use the following: \n",
    "\n",
    "- `tf.placeholder(tf.float32, name = \"...\")`\n",
    "- `tf.sigmoid(...)`\n",
    "- `sess.run(..., feed_dict = {x: z})`\n",
    "\n",
    "\n",
    "Note that there are two typical ways to create and use sessions in tensorflow: \n",
    "\n",
    "**Method 1:**\n",
    "```python\n",
    "sess = tf.Session()\n",
    "# Run the variables initialization (if needed), run the operations\n",
    "result = sess.run(..., feed_dict = {...})\n",
    "sess.close() # Close the session\n",
    "```\n",
    "**Method 2:**\n",
    "```python\n",
    "with tf.Session() as sess: \n",
    "    # run the variables initialization (if needed), run the operations\n",
    "    result = sess.run(..., feed_dict = {...})\n",
    "    # This takes care of closing the session for you :)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: sigmoid\n",
    "\n",
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    Computes the sigmoid of z\n",
    "    \n",
    "    Arguments:\n",
    "    z -- input value, scalar or vector\n",
    "    \n",
    "    Returns: \n",
    "    results -- the sigmoid of z\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### ( approx. 4 lines of code)\n",
    "    # Create a placeholder for x. Name it 'x'.\n",
    "    x = tf.placeholder(tf.float32, name = \"x\")\n",
    "\n",
    "    # compute sigmoid(x)\n",
    "    sigmoid = tf.sigmoid(x)\n",
    "\n",
    "    # Create a session, and run it. Please use the method 2 explained above. \n",
    "    # You should use a feed_dict to pass z's value to x. \n",
    "    with tf.Session() as sess: \n",
    "        # Run session and call the output \"result\"\n",
    "        result =sess.run(sigmoid, feed_dict = {x: z})\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid(0) = 0.5\n",
      "sigmoid(12) = 0.9999938\n"
     ]
    }
   ],
   "source": [
    "print (\"sigmoid(0) = \" + str(sigmoid(0)))\n",
    "print (\"sigmoid(12) = \" + str(sigmoid(12)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*** Expected Output ***: \n",
    "\n",
    "<table> \n",
    "<tr> \n",
    "<td>\n",
    "**sigmoid(0)**\n",
    "</td>\n",
    "<td>\n",
    "0.5\n",
    "</td>\n",
    "</tr>\n",
    "<tr> \n",
    "<td>\n",
    "**sigmoid(12)**\n",
    "</td>\n",
    "<td>\n",
    "0.999994\n",
    "</td>\n",
    "</tr> \n",
    "\n",
    "</table> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "**To summarize, you how know how to**:\n",
    "1. Create placeholders\n",
    "2. Specify the computation graph corresponding to operations you want to compute\n",
    "3. Create the session\n",
    "4. Run the session, using a feed dictionary if necessary to specify placeholder variables' values. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 -  Computing the Cost\n",
    "\n",
    "You can also use a built-in function to compute the cost of your neural network. So instead of needing to write code to compute this as a function of $a^{[2](i)}$ and $y^{(i)}$ for i=1...m: \n",
    "$$ J = - \\frac{1}{m}  \\sum_{i = 1}^m  \\large ( \\small y^{(i)} \\log a^{ [2] (i)} + (1-y^{(i)})\\log (1-a^{ [2] (i)} )\\large )\\small\\tag{2}$$\n",
    "\n",
    "you can do it in one line of code in tensorflow!\n",
    "\n",
    "**Exercise**: Implement the cross entropy loss. The function you will use is: \n",
    "\n",
    "\n",
    "- `tf.nn.sigmoid_cross_entropy_with_logits(logits = ...,  labels = ...)`\n",
    "\n",
    "Your code should input `z`, compute the sigmoid (to get `a`) and then compute the cross entropy cost $J$. All this can be done using one call to `tf.nn.sigmoid_cross_entropy_with_logits`, which computes\n",
    "\n",
    "$$- \\frac{1}{m}  \\sum_{i = 1}^m  \\large ( \\small y^{(i)} \\log \\sigma(z^{[2](i)}) + (1-y^{(i)})\\log (1-\\sigma(z^{[2](i)})\\large )\\small\\tag{2}$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: cost\n",
    "\n",
    "def cost(logits, labels):\n",
    "    \"\"\"\n",
    "    Computes the cost using the sigmoid cross entropy\n",
    "    \n",
    "    Arguments:\n",
    "    logits -- vector containing z, output of the last linear unit (before the final sigmoid activation)\n",
    "    labels -- vector of labels y (1 or 0) \n",
    "    \n",
    "    Note: What we've been calling \"z\" and \"y\" in this class are respectively called \"logits\" and \"labels\" \n",
    "    in the TensorFlow documentation. So logits will feed into z, and labels into y. \n",
    "    \n",
    "    Returns:\n",
    "    cost -- runs the session of the cost (formula (2))\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### \n",
    "    \n",
    "    # Create the placeholders for \"logits\" (z) and \"labels\" (y) (approx. 2 lines)\n",
    "    z = tf.placeholder(tf.float32, name = \"z\")\n",
    "    y = tf.placeholder(tf.float32, name = \"y\")\n",
    "    \n",
    "    # Use the loss function (approx. 1 line)\n",
    "    cost = tf.nn.sigmoid_cross_entropy_with_logits(logits = z, labels =y)\n",
    "    \n",
    "    # Create a session (approx. 1 line). See method 1 above.\n",
    "    sess = tf.Session()\n",
    "    \n",
    "    # Run the session (approx. 1 line).\n",
    "    cost = sess.run(cost,feed_dict={z:logits,y:labels})\n",
    "    \n",
    "    # Close the session (approx. 1 line). See method 1 above.\n",
    "    sess.close()\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost = [1.0053872  1.0366408  0.41385433 0.39956617]\n"
     ]
    }
   ],
   "source": [
    "logits = sigmoid(np.array([0.2,0.4,0.7,0.9]))\n",
    "cost = cost(logits, np.array([0,0,1,1]))\n",
    "print (\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Expected Output** : \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **cost**\n",
    "        </td>\n",
    "        <td>\n",
    "        [ 1.00538719  1.03664088  0.41385433  0.39956614]\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 - Using One Hot encodings\n",
    "\n",
    "Many times in deep learning you will have a y vector with numbers ranging from 0 to C-1, where C is the number of classes. If C is for example 4, then you might have the following y vector which you will need to convert as follows:\n",
    "\n",
    "\n",
    "<img src=\"images/onehot.png\" style=\"width:600px;height:150px;\">\n",
    "\n",
    "This is called a \"one hot\" encoding, because in the converted representation exactly one element of each column is \"hot\" (meaning set to 1). To do this conversion in numpy, you might have to write a few lines of code. In tensorflow, you can use one line of code: \n",
    "\n",
    "- tf.one_hot(labels, depth, axis) \n",
    "\n",
    "**Exercise:** Implement the function below to take one vector of labels and the total number of classes $C$, and return the one hot encoding. Use `tf.one_hot()` to do this. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: one_hot_matrix\n",
    "\n",
    "def one_hot_matrix(labels, C):\n",
    "    \"\"\"\n",
    "    Creates a matrix where the i-th row corresponds to the ith class number and the jth column\n",
    "                     corresponds to the jth training example. So if example j had a label i. Then entry (i,j) \n",
    "                     will be 1. \n",
    "                     \n",
    "    Arguments:\n",
    "    labels -- vector containing the labels \n",
    "    C -- number of classes, the depth of the one hot dimension\n",
    "    \n",
    "    Returns: \n",
    "    one_hot -- one hot matrix\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    \n",
    "    # Create a tf.constant equal to C (depth), name it 'C'. (approx. 1 line)\n",
    "    C = tf.constant(C, name = \"C\")\n",
    "    \n",
    "    # Use tf.one_hot, be careful with the axis (approx. 1 line)\n",
    "    one_hot_matrix = tf.one_hot(labels, C, axis=0)\n",
    "    \n",
    "    # Create the session (approx. 1 line)\n",
    "    sess = tf.Session()\n",
    "    \n",
    "    # Run the session (approx. 1 line)\n",
    "    one_hot = sess.run(one_hot_matrix)\n",
    "    \n",
    "    # Close the session (approx. 1 line). See method 1 above.\n",
    "    sess.close()\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return one_hot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one_hot = [[0. 0. 0. 1. 0. 0.]\n",
      " [1. 0. 0. 0. 0. 1.]\n",
      " [0. 1. 0. 0. 1. 0.]\n",
      " [0. 0. 1. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "labels = np.array([1,2,3,0,2,1])\n",
    "one_hot = one_hot_matrix(labels, C = 4)\n",
    "print (\"one_hot = \" + str(one_hot))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **one_hot**\n",
    "        </td>\n",
    "        <td>\n",
    "        [[ 0.  0.  0.  1.  0.  0.]\n",
    " [ 1.  0.  0.  0.  0.  1.]\n",
    " [ 0.  1.  0.  0.  1.  0.]\n",
    " [ 0.  0.  1.  0.  0.  0.]]\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5 - Initialize with zeros and ones\n",
    "\n",
    "Now you will learn how to initialize a vector of zeros and ones. The function you will be calling is `tf.ones()`. To initialize with zeros you could use tf.zeros() instead. These functions take in a shape and return an array of dimension shape full of zeros and ones respectively. \n",
    "\n",
    "**Exercise:** Implement the function below to take in a shape and to return an array (of the shape's dimension of ones). \n",
    "\n",
    " - tf.ones(shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: ones\n",
    "\n",
    "def ones(shape):\n",
    "    \"\"\"\n",
    "    Creates an array of ones of dimension shape\n",
    "    \n",
    "    Arguments:\n",
    "    shape -- shape of the array you want to create\n",
    "        \n",
    "    Returns: \n",
    "    ones -- array containing only ones\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    \n",
    "    # Create \"ones\" tensor using tf.ones(...). (approx. 1 line)\n",
    "    ones = tf.ones(shape)\n",
    "    \n",
    "    # Create the session (approx. 1 line)\n",
    "    sess = tf.Session()\n",
    "    \n",
    "    # Run the session to compute 'ones' (approx. 1 line)\n",
    "    ones = sess.run(ones)\n",
    "    \n",
    "    # Close the session (approx. 1 line). See method 1 above.\n",
    "    sess.close()\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    return ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ones = [1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "print (\"ones = \" + str(ones([3])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **ones**\n",
    "        </td>\n",
    "        <td>\n",
    "        [ 1.  1.  1.]\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 - Building your first neural network in tensorflow\n",
    "\n",
    "In this part of the assignment you will build a neural network using tensorflow. Remember that there are two parts to implement a tensorflow model:\n",
    "\n",
    "- Create the computation graph\n",
    "- Run the graph\n",
    "\n",
    "Let's delve into the problem you'd like to solve!\n",
    "\n",
    "### 2.0 - Problem statement: SIGNS Dataset\n",
    "\n",
    "One afternoon, with some friends we decided to teach our computers to decipher sign language. We spent a few hours taking pictures in front of a white wall and came up with the following dataset. It's now your job to build an algorithm that would facilitate communications from a speech-impaired person to someone who doesn't understand sign language.\n",
    "\n",
    "- **Training set**: 1080 pictures (64 by 64 pixels) of signs representing numbers from 0 to 5 (180 pictures per number).\n",
    "- **Test set**: 120 pictures (64 by 64 pixels) of signs representing numbers from 0 to 5 (20 pictures per number).\n",
    "\n",
    "Note that this is a subset of the SIGNS dataset. The complete dataset contains many more signs.\n",
    "\n",
    "Here are examples for each number, and how an explanation of how we represent the labels. These are the original pictures, before we lowered the image resolutoion to 64 by 64 pixels.\n",
    "<img src=\"images/hands.png\" style=\"width:800px;height:350px;\"><caption><center> <u><font color='purple'> **Figure 1**</u><font color='purple'>: SIGNS dataset <br> <font color='black'> </center>\n",
    "\n",
    "\n",
    "Run the following code to load the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the dataset\n",
    "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Change the index below and run the cell to visualize some examples in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 5\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 0\n",
    "plt.imshow(X_train_orig[index])\n",
    "print (\"y = \" + str(np.squeeze(Y_train_orig[:, index])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual you flatten the image dataset, then normalize it by dividing by 255. On top of that, you will convert each label to a one-hot vector as shown in Figure 1. Run the cell below to do so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training examples = 1080\n",
      "number of test examples = 120\n",
      "X_train shape: (12288, 1080)\n",
      "Y_train shape: (6, 1080)\n",
      "X_test shape: (12288, 120)\n",
      "Y_test shape: (6, 120)\n"
     ]
    }
   ],
   "source": [
    "# Flatten the training and test images\n",
    "X_train_flatten = X_train_orig.reshape(X_train_orig.shape[0], -1).T\n",
    "X_test_flatten = X_test_orig.reshape(X_test_orig.shape[0], -1).T\n",
    "# Normalize image vectors\n",
    "X_train = X_train_flatten/255.\n",
    "X_test = X_test_flatten/255.\n",
    "# Convert training and test labels to one hot matrices\n",
    "Y_train = convert_to_one_hot(Y_train_orig, 6)\n",
    "Y_test = convert_to_one_hot(Y_test_orig, 6)\n",
    "\n",
    "print (\"number of training examples = \" + str(X_train.shape[1]))\n",
    "print (\"number of test examples = \" + str(X_test.shape[1]))\n",
    "print (\"X_train shape: \" + str(X_train.shape))\n",
    "print (\"Y_train shape: \" + str(Y_train.shape))\n",
    "print (\"X_test shape: \" + str(X_test.shape))\n",
    "print (\"Y_test shape: \" + str(Y_test.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note** that 12288 comes from $64 \\times 64 \\times 3$. Each image is square, 64 by 64 pixels, and 3 is for the RGB colors. Please make sure all these shapes make sense to you before continuing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Your goal** is to build an algorithm capable of recognizing a sign with high accuracy. To do so, you are going to build a tensorflow model that is almost the same as one you have previously built in numpy for cat recognition (but now using a softmax output). It is a great occasion to compare your numpy implementation to the tensorflow one. \n",
    "\n",
    "**The model** is *LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX*. The SIGMOID output layer has been converted to a SOFTMAX. A SOFTMAX layer generalizes SIGMOID to when there are more than two classes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 - Create placeholders\n",
    "\n",
    "Your first task is to create placeholders for `X` and `Y`. This will allow you to later pass your training data in when you run your session. \n",
    "\n",
    "**Exercise:** Implement the function below to create the placeholders in tensorflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: create_placeholders\n",
    "\n",
    "def create_placeholders(n_x, n_y):\n",
    "    \"\"\"\n",
    "    Creates the placeholders for the tensorflow session.\n",
    "    \n",
    "    Arguments:\n",
    "    n_x -- scalar, size of an image vector (num_px * num_px = 64 * 64 * 3 = 12288)\n",
    "    n_y -- scalar, number of classes (from 0 to 5, so -> 6)\n",
    "    \n",
    "    Returns:\n",
    "    X -- placeholder for the data input, of shape [n_x, None] and dtype \"float\"\n",
    "    Y -- placeholder for the input labels, of shape [n_y, None] and dtype \"float\"\n",
    "    \n",
    "    Tips:\n",
    "    - You will use None because it let's us be flexible on the number of examples you will for the placeholders.\n",
    "      In fact, the number of examples during test/train is different.\n",
    "    \"\"\"\n",
    "\n",
    "    ### START CODE HERE ### (approx. 2 lines)\n",
    "    X = tf.placeholder(shape=[n_x, None],dtype=tf.float32)\n",
    "    Y = tf.placeholder(shape=[n_y, None],dtype=tf.float32)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X = Tensor(\"Placeholder:0\", shape=(12288, ?), dtype=float32)\n",
      "Y = Tensor(\"Placeholder_1:0\", shape=(6, ?), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "X, Y = create_placeholders(12288, 6)\n",
    "print (\"X = \" + str(X))\n",
    "print (\"Y = \" + str(Y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **X**\n",
    "        </td>\n",
    "        <td>\n",
    "        Tensor(\"Placeholder_1:0\", shape=(12288, ?), dtype=float32) (not necessarily Placeholder_1)\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **Y**\n",
    "        </td>\n",
    "        <td>\n",
    "        Tensor(\"Placeholder_2:0\", shape=(6, ?), dtype=float32) (not necessarily Placeholder_2)\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 - Initializing the parameters\n",
    "\n",
    "Your second task is to initialize the parameters in tensorflow.\n",
    "\n",
    "**Exercise:** Implement the function below to initialize the parameters in tensorflow. You are going use Xavier Initialization for weights and Zero Initialization for biases. The shapes are given below. As an example, to help you, for W1 and b1 you could use: \n",
    "\n",
    "```python\n",
    "W1 = tf.get_variable(\"W1\", [25,12288], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "b1 = tf.get_variable(\"b1\", [25,1], initializer = tf.zeros_initializer())\n",
    "```\n",
    "Please use `seed = 1` to make sure your results match ours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: initialize_parameters\n",
    "\n",
    "def initialize_parameters():\n",
    "    \"\"\"\n",
    "    Initializes parameters to build a neural network with tensorflow. The shapes are:\n",
    "                        W1 : [25, 12288]\n",
    "                        b1 : [25, 1]\n",
    "                        W2 : [12, 25]\n",
    "                        b2 : [12, 1]\n",
    "                        W3 : [6, 12]\n",
    "                        b3 : [6, 1]\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- a dictionary of tensors containing W1, b1, W2, b2, W3, b3\n",
    "    \"\"\"\n",
    "    \n",
    "    tf.set_random_seed(1)                   # so that your \"random\" numbers match ours\n",
    "        \n",
    "    ### START CODE HERE ### (approx. 6 lines of code)\n",
    "    W1 = tf.get_variable(\"W1\", [25,12288], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    b1 = tf.get_variable(\"b1\", [25,1], initializer = tf.zeros_initializer())\n",
    "    W2 = tf.get_variable(\"W2\", [12,25], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    b2 = tf.get_variable(\"b2\", [12,1], initializer = tf.zeros_initializer())\n",
    "    W3 = tf.get_variable(\"W3\", [6,12], initializer = tf.contrib.layers.xavier_initializer(seed = 1))\n",
    "    b3 = tf.get_variable(\"b3\", [6,1], initializer = tf.zeros_initializer())\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    parameters = {\"W1\": W1,\n",
    "                  \"b1\": b1,\n",
    "                  \"W2\": W2,\n",
    "                  \"b2\": b2,\n",
    "                  \"W3\": W3,\n",
    "                  \"b3\": b3}\n",
    "    \n",
    "    return parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "W1 = <tf.Variable 'W1:0' shape=(25, 12288) dtype=float32_ref>\n",
      "b1 = <tf.Variable 'b1:0' shape=(25, 1) dtype=float32_ref>\n",
      "W2 = <tf.Variable 'W2:0' shape=(12, 25) dtype=float32_ref>\n",
      "b2 = <tf.Variable 'b2:0' shape=(12, 1) dtype=float32_ref>\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    parameters = initialize_parameters()\n",
    "    print(\"W1 = \" + str(parameters[\"W1\"]))\n",
    "    print(\"b1 = \" + str(parameters[\"b1\"]))\n",
    "    print(\"W2 = \" + str(parameters[\"W2\"]))\n",
    "    print(\"b2 = \" + str(parameters[\"b2\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **W1**\n",
    "        </td>\n",
    "        <td>\n",
    "         < tf.Variable 'W1:0' shape=(25, 12288) dtype=float32_ref >\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **b1**\n",
    "        </td>\n",
    "        <td>\n",
    "        < tf.Variable 'b1:0' shape=(25, 1) dtype=float32_ref >\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **W2**\n",
    "        </td>\n",
    "        <td>\n",
    "        < tf.Variable 'W2:0' shape=(12, 25) dtype=float32_ref >\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **b2**\n",
    "        </td>\n",
    "        <td>\n",
    "        < tf.Variable 'b2:0' shape=(12, 1) dtype=float32_ref >\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the parameters haven't been evaluated yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 - Forward propagation in tensorflow \n",
    "\n",
    "You will now implement the forward propagation module in tensorflow. The function will take in a dictionary of parameters and it will complete the forward pass. The functions you will be using are: \n",
    "\n",
    "- `tf.add(...,...)` to do an addition\n",
    "- `tf.matmul(...,...)` to do a matrix multiplication\n",
    "- `tf.nn.relu(...)` to apply the ReLU activation\n",
    "\n",
    "**Question:** Implement the forward pass of the neural network. We commented for you the numpy equivalents so that you can compare the tensorflow implementation to numpy. It is important to note that the forward propagation stops at `z3`. The reason is that in tensorflow the last linear layer output is given as input to the function computing the loss. Therefore, you don't need `a3`!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: forward_propagation\n",
    "\n",
    "def forward_propagation(X, parameters):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SOFTMAX\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input dataset placeholder, of shape (input size, number of examples)\n",
    "    parameters -- python dictionary containing your parameters \"W1\", \"b1\", \"W2\", \"b2\", \"W3\", \"b3\"\n",
    "                  the shapes are given in initialize_parameters\n",
    "\n",
    "    Returns:\n",
    "    Z3 -- the output of the last LINEAR unit\n",
    "    \"\"\"\n",
    "    \n",
    "    # Retrieve the parameters from the dictionary \"parameters\" \n",
    "    W1 = parameters['W1']\n",
    "    b1 = parameters['b1']\n",
    "    W2 = parameters['W2']\n",
    "    b2 = parameters['b2']\n",
    "    W3 = parameters['W3']\n",
    "    b3 = parameters['b3']\n",
    "    \n",
    "    ### START CODE HERE ### (approx. 5 lines)              # Numpy Equivalents:\n",
    "    Z1 = tf.add(tf.matmul(W1,X),b1)                                              # Z1 = np.dot(W1, X) + b1\n",
    "    A1 = tf.nn.relu(Z1)                                              # A1 = relu(Z1)\n",
    "    Z2 = tf.add(tf.matmul(W2,A1),b2)                                              # Z2 = np.dot(W2, a1) + b2\n",
    "    A2 = tf.nn.relu(Z2)                                              # A2 = relu(Z2)\n",
    "    Z3 = tf.add(tf.matmul(W3,A2),b3)                                              # Z3 = np.dot(W3,Z2) + b3\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return Z3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z3 = Tensor(\"Add_2:0\", shape=(6, ?), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    X, Y = create_placeholders(12288, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    print(\"Z3 = \" + str(Z3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **Z3**\n",
    "        </td>\n",
    "        <td>\n",
    "        Tensor(\"Add_2:0\", shape=(6, ?), dtype=float32)\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may have noticed that the forward propagation doesn't output any cache. You will understand why below, when we get to brackpropagation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Compute cost\n",
    "\n",
    "As seen before, it is very easy to compute the cost using:\n",
    "```python\n",
    "tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = ..., labels = ...))\n",
    "```\n",
    "**Question**: Implement the cost function below. \n",
    "- It is important to know that the \"`logits`\" and \"`labels`\" inputs of `tf.nn.softmax_cross_entropy_with_logits` are expected to be of shape (number of examples, num_classes). We have thus transposed Z3 and Y for you.\n",
    "- Besides, `tf.reduce_mean` basically does the summation over the examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: compute_cost \n",
    "\n",
    "def compute_cost(Z3, Y):\n",
    "    \"\"\"\n",
    "    Computes the cost\n",
    "    \n",
    "    Arguments:\n",
    "    Z3 -- output of forward propagation (output of the last LINEAR unit), of shape (6, number of examples)\n",
    "    Y -- \"true\" labels vector placeholder, same shape as Z3\n",
    "    \n",
    "    Returns:\n",
    "    cost - Tensor of the cost function\n",
    "    \"\"\"\n",
    "    \n",
    "    # to fit the tensorflow requirement for tf.nn.softmax_cross_entropy_with_logits(...,...)\n",
    "    logits = tf.transpose(Z3)\n",
    "    labels = tf.transpose(Y)\n",
    "    \n",
    "    ### START CODE HERE ### (1 line of code)\n",
    "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits =logits , labels = labels))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost = Tensor(\"Mean:0\", shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    X, Y = create_placeholders(12288, 6)\n",
    "    parameters = initialize_parameters()\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    cost = compute_cost(Z3, Y)\n",
    "    print(\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **cost**\n",
    "        </td>\n",
    "        <td>\n",
    "        Tensor(\"Mean:0\", shape=(), dtype=float32)\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 - Backward propagation & parameter updates\n",
    "\n",
    "This is where you become grateful to programming frameworks. All the backpropagation and the parameters update is taken care of in 1 line of code. It is very easy to incorporate this line in the model.\n",
    "\n",
    "After you compute the cost function. You will create an \"`optimizer`\" object. You have to call this object along with the cost when running the tf.session. When called, it will perform an optimization on the given cost with the chosen method and learning rate.\n",
    "\n",
    "For instance, for gradient descent the optimizer would be:\n",
    "```python\n",
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate = learning_rate).minimize(cost)\n",
    "```\n",
    "\n",
    "To make the optimization you would do:\n",
    "```python\n",
    "_ , c = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})\n",
    "```\n",
    "\n",
    "This computes the backpropagation by passing through the tensorflow graph in the reverse order. From cost to inputs.\n",
    "\n",
    "**Note** When coding, we often use `_` as a \"throwaway\" variable to store values that we won't need to use later. Here, `_` takes on the evaluated value of `optimizer`, which we don't need (and `c` takes the value of the `cost` variable). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 - Building the model\n",
    "\n",
    "Now, you will bring it all together! \n",
    "\n",
    "**Exercise:** Implement the model. You will be calling the functions you had previously implemented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,\n",
    "          num_epochs = 1500, minibatch_size = 32, print_cost = True):\n",
    "    \"\"\"\n",
    "    Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set, of shape (input size = 12288, number of training examples = 1080)\n",
    "    Y_train -- test set, of shape (output size = 6, number of training examples = 1080)\n",
    "    X_test -- training set, of shape (input size = 12288, number of training examples = 120)\n",
    "    Y_test -- test set, of shape (output size = 6, number of test examples = 120)\n",
    "    learning_rate -- learning rate of the optimization\n",
    "    num_epochs -- number of epochs of the optimization loop\n",
    "    minibatch_size -- size of a minibatch\n",
    "    print_cost -- True to print the cost every 100 epochs\n",
    "    \n",
    "    Returns:\n",
    "    parameters -- parameters learnt by the model. They can then be used to predict.\n",
    "    \"\"\"\n",
    "    \n",
    "    ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables\n",
    "    tf.set_random_seed(1)                             # to keep consistent results\n",
    "    seed = 3                                          # to keep consistent results\n",
    "    (n_x, m) = X_train.shape                          # (n_x: input size, m : number of examples in the train set)\n",
    "    n_y = Y_train.shape[0]                            # n_y : output size\n",
    "    costs = []                                        # To keep track of the cost\n",
    "    \n",
    "    # Create Placeholders of shape (n_x, n_y)\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    X, Y = create_placeholders(n_x, n_y)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Initialize parameters\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    parameters = initialize_parameters()\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Forward propagation: Build the forward propagation in the tensorflow graph\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    Z3 = forward_propagation(X, parameters)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Cost function: Add cost function to tensorflow graph\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    cost = compute_cost(Z3, Y)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.\n",
    "    ### START CODE HERE ### (1 line)\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Initialize all the variables\n",
    "    init = tf.global_variables_initializer()\n",
    "\n",
    "    # Start the session to compute the tensorflow graph\n",
    "    with tf.Session() as sess:\n",
    "        \n",
    "        # Run the initialization\n",
    "        sess.run(init)\n",
    "        \n",
    "        # Do the training loop\n",
    "        for epoch in range(num_epochs):\n",
    "\n",
    "            epoch_cost = 0.                       # Defines a cost related to an epoch\n",
    "            num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set\n",
    "            seed = seed + 1\n",
    "            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n",
    "\n",
    "            for minibatch in minibatches:\n",
    "\n",
    "                # Select a minibatch\n",
    "                (minibatch_X, minibatch_Y) = minibatch\n",
    "                \n",
    "                # IMPORTANT: The line that runs the graph on a minibatch.\n",
    "                # Run the session to execute the \"optimizer\" and the \"cost\", the feedict should contain a minibatch for (X,Y).\n",
    "                ### START CODE HERE ### (1 line)\n",
    "                _ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})\n",
    "                ### END CODE HERE ###\n",
    "                \n",
    "                epoch_cost += minibatch_cost / num_minibatches\n",
    "\n",
    "            # Print the cost every epoch\n",
    "            if print_cost == True and epoch % 100 == 0:\n",
    "                print (\"Cost after epoch %i: %f\" % (epoch, epoch_cost))\n",
    "            if print_cost == True and epoch % 5 == 0:\n",
    "                costs.append(epoch_cost)\n",
    "                \n",
    "        # plot the cost\n",
    "        plt.plot(np.squeeze(costs))\n",
    "        plt.ylabel('cost')\n",
    "        plt.xlabel('iterations (per tens)')\n",
    "        plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "        plt.show()\n",
    "\n",
    "        # lets save the parameters in a variable\n",
    "        parameters = sess.run(parameters)\n",
    "        print (\"Parameters have been trained!\")\n",
    "\n",
    "        # Calculate the correct predictions\n",
    "        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))\n",
    "\n",
    "        # Calculate accuracy on the test set\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "\n",
    "        print (\"Train Accuracy:\", accuracy.eval({X: X_train, Y: Y_train}))\n",
    "        print (\"Test Accuracy:\", accuracy.eval({X: X_test, Y: Y_test}))\n",
    "        \n",
    "        return parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Run the following cell to train your model! On our machine it takes about 5 minutes. Your \"Cost after epoch 100\" should be 1.016458. If it's not, don't waste time; interrupt the training by clicking on the square (⬛) in the upper bar of the notebook, and try to correct your code. If it is the correct cost, take a break and come back in 5 minutes!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after epoch 0: 1.855702\n",
      "Cost after epoch 100: 1.017255\n",
      "Cost after epoch 200: 0.733184\n",
      "Cost after epoch 300: 0.573071\n",
      "Cost after epoch 400: 0.468699\n",
      "Cost after epoch 500: 0.381209\n",
      "Cost after epoch 600: 0.313826\n",
      "Cost after epoch 700: 0.253723\n",
      "Cost after epoch 800: 0.203884\n",
      "Cost after epoch 900: 0.166440\n",
      "Cost after epoch 1000: 0.146653\n",
      "Cost after epoch 1100: 0.107271\n",
      "Cost after epoch 1200: 0.086612\n",
      "Cost after epoch 1300: 0.059327\n",
      "Cost after epoch 1400: 0.052237\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEWCAYAAAB1xKBvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xd4HNXV+PHvUe/Nklwk2XLFBWxjC9t0E0pMCU4CARNqEuKEhPS8hJQXSP1BCCHhBUKHkFBDSRwIECDYJhgX2bh3y7YsN8nqklVX5/fHjMxaqKxsrWYlnc/z7KPdO3dmz9Xae3TvnbkjqooxxhjTlTCvAzDGGNM3WMIwxhgTEEsYxhhjAmIJwxhjTEAsYRhjjAmIJQxjjDEBsYRh+j0ReUNErvc6DmP6OksYJmhEZJeInOd1HKp6oar+2es4AERkoYjc2AvvEy0iT4hIlYgcEJHvd1H/e269Sne/aL9tuSLynogcFpHNbT/TLvb9pYisE5FmEbmjxxtqepUlDNOniUiE1zG0CqVYgDuAscAI4BzgFhGZ015FEfk0cCtwLpALjAJ+7lflOeAjYBDwU+AlEckIcN/twC3A6z3SKuMpSxjGEyJyiYisFpEKEVkiIpP9tt0qIjtEpFpENorI5/y23SAiH4jIvSJSBtzhlv1XRH4nIuUislNELvTb58hf9QHUHSkii933fkdEHhCRv3bQhtkiUiQiPxKRA8CTIpIqIq+JSIl7/NdEJNut/2vgTOB+EakRkfvd8vEi8raIlInIFhG5ogd+xdcBv1TVclXdBDwK3NBB3euBx1V1g6qWA79srSsi44BpwO2qWqeqLwPrgMu62hdAVf+sqm8A1T3QJuMxSxim14nINOAJ4Gs4f7U+DCzwG8rYgfPFmozz1+pfRWSo3yFmAgVAJvBrv7ItQDrwW+BxEZEOQuis7rPAcjeuO4Bru2jOECAN5y/5+Tj/p550Xw8H6oD7AVT1p8D7wM2qmqCqN4tIPPC2+76ZwFXAgyIyqb03E5EH3STb3mOtWycVGAas8dt1DdDuMd3ytnUHi8ggd1uBqla32T4pgH1NP2MJw3jhq8DDqrpMVX3u/EIDMAtAVf+mqvtUtUVVXwC2ATP89t+nqv+nqs2qWueW7VbVR1XVB/wZGAoM7uD9260rIsOBU4DbVLVRVf8LLOiiLS04f303uH+Bl6rqy6p62P2S/TVwdif7XwLsUtUn3fasAl4GLm+vsqp+Q1VTOni09tIS3J+VfrtWAokdxJDQTl3c+m23tT1WZ/uafsYShvHCCOAH/n8dAzk4fxUjItf5DVdVACfi9AZa7WnnmAdan6jqYfdpQjv1Oqs7DCjzK+vovfyVqGp96wsRiRORh0Vkt4hUAYuBFBEJ72D/EcDMNr+Lq3F6Lseqxv2Z5FeWRMfDQjXt1MWt33Zb22N1tq/pZyxhGC/sAX7d5q/jOFV9TkRG4Iy33wwMUtUUYD3gP7wUrCWW9wNpIhLnV5bTxT5tY/kBcAIwU1WTgLPccumg/h5gUZvfRYKq3tTem4nIQ+78R3uPDQDuXMJ+YIrfrlOADR20YUM7dQ+qaqm7bZSIJLbZviGAfU0/YwnDBFukiMT4PSJwEsLXRWSmOOJF5GL3Syke50u1BEBEvoTTwwg6Vd0N5ONMpEeJyKnAZ7p5mESceYsKEUkDbm+z/SDOmUStXgPGici1IhLpPk4RkQkdxPh1N6G09/Cfo3ga+Jk7CT8eZxjwqQ5ifhr4iohMdOc/ftZaV1W3AquB293P73PAZJxhs073BXDbE4PzXRPhHqOj3pYJcZYwTLD9C+cLtPVxh6rm43yB3Q+U45x6eQOAqm4E7gE+xPlyPQn4oBfjvRo4FSgFfgW8gDO/Eqg/ALHAIWAp8Gab7X8ELnfPoLrPnee4AJgH7MMZLrsLiOb43I5z8sBuYBFwt6q+CSAiw90eyXAAt/y3wHtu/d0cnejmAXk4n9WdwOWqWhLgvo/ifO5X4ZySW0fXJxKYECV2AyVjOiYiLwCbVbVtT8GYAcd6GMb4cYeDRotImDgXus0F/u51XMaEglC6MtWYUDAEeAXnOowi4CZV/cjbkIwJDTYkZYwxJiA2JGWMMSYg/WpIKj09XXNzc70Owxhj+oyVK1ceUtWMQOr2q4SRm5tLfn6+12EYY0yfISK7A61rQ1LGGGMCYgnDGGNMQCxhGGOMCYglDGOMMQGxhGGMMSYgljCMMcYExBKGMcaYgAz4hFHf5OPRxQUs2X7I61CMMSakDfiEEREmPPJ+AU98sNPrUIwxJqRZwggP47Jp2by3pYTi6vqudzDGmAFqwCcMgC/kZeNrUV5dtdfrUIwxJmRZwgBGZyQwNSeFBWv2eR2KMcaELEsYrksmD2XDvip2Hqr1OhRjjAlJljBcF08eCsDra62XYYwx7bGE4RqaHMvk7GQWb7PTa40xpj2WMPycOnoQHxWWU9fo8zoUY4wJOZYw/Jw6ahBNPiV/d5nXoRhjTMgJWsIQkSdEpFhE1new/X9EZLX7WC8iPhFJc7ftEpF17rZeu4XeKblpRIQJS3aU9tZbGmNMnxHMHsZTwJyONqrq3ao6VVWnAj8GFqmq/5/257jb84IY41HioyOYPiKVhVtKeustjTGmzwhawlDVxUCgYztXAc8FK5buOGd8Jpv2V7G/ss7rUIwxJqR4PochInE4PZGX/YoV+LeIrBSR+V3sP19E8kUkv6Tk+HsGnxqfCcB7m62XYYwx/jxPGMBngA/aDEedrqrTgAuBb4rIWR3trKqPqGqequZlZGQcdzBjMxPISoll8VZLGMYY4y8UEsY82gxHqeo+92cx8Cowo7eCERFmjkpjxa4yVLW33tYYY0KepwlDRJKBs4F/+JXFi0hi63PgAqDdM62CZebINEprG9lRUtObb2uMMSEtIlgHFpHngNlAuogUAbcDkQCq+pBb7XPAv1XVfwGnwcCrItIa37Oq+maw4mzPzJGDAFhaUMaYzMTefGtjjAlZQUsYqnpVAHWewjn91r+sAJgSnKgCM2JQHJmJ0SzfWcY1s0Z4GYoxxoSMUJjDCDnOPMYglu0stXkMY4xxWcLowIyRaRysaqCw7LDXoRhjTEiwhNGBWSPTAFhWYOtKGWMMWMLo0JjMBNLio1i20xKGMcaAJYwOiQgzctNYvssWIjTGGLCE0akZI9PYU1bHvgpbV8oYYyxhdGKGO4+x3IaljDHGEkZnJgxNIjEmwuYxjDEGSxidCg8TpmSnsH5vpdehGGOM5yxhdGHC0ES2HKym2dfidSjGGOMpSxhdmDgsicbmFgoO1XZd2Rhj+jFLGF2YMDQJgE37qzyOxBhjvGUJowujMxKICg9joyUMY8wAZwmjC5HhYZwwJJG1e2zi2xgzsFnCCMCMkWmsKiynodnndSjGGOMZSxgBmDVqEA3NLawurPA6FGOM8YwljADMyE1DxLkDnzHGDFSWMAKQHBfJpGFJfFhwyOtQjDHGM0FLGCLyhIgUi8j6DrbPFpFKEVntPm7z2zZHRLaIyHYRuTVYMXbHrJGDWFVYQX2TzWMYYwamYPYwngLmdFHnfVWd6j5+ASAi4cADwIXAROAqEZkYxDgDMmvUIBqbW1i9x+YxjDEDU9AShqouBo5l0H8GsF1VC1S1EXgemNujwR2DU0amESbw4Q67P4YxZmDyeg7jVBFZIyJviMgktywL2ONXp8gta5eIzBeRfBHJLykpCVqgybGRTBqWzNICSxjGmIHJy4SxChihqlOA/wP+7pZLO3W1o4Oo6iOqmqeqeRkZGUEI82OzRqXx0R6bxzDGDEyeJQxVrVLVGvf5v4BIEUnH6VHk+FXNBvZ5EOInnDramcdYVVjudSjGGNPrPEsYIjJERMR9PsONpRRYAYwVkZEiEgXMAxZ4Fae/vFxnHsOuxzDGDEQRwTqwiDwHzAbSRaQIuB2IBFDVh4DLgZtEpBmoA+apqgLNInIz8BYQDjyhqhuCFWd3JMVEcmKWzWMYYwamoCUMVb2qi+33A/d3sO1fwL+CEdfxmjVqEE99sIv6Jh8xkeFeh2OMMb3G67Ok+pxTRw2i0dfCqt02j2GMGVgsYXRTXm6qO49hw1LGmIHFEkY3JcZEclJWMkt32sS3MWZgsYRxDKaNSGVdUSXNvhavQzHGmF5jCeMYTM1Joa7Jx5aD1V6HYowxvcYSxjE4OScVgI/shkrGmAHEEsYxyEmLZVB8lK1ca4wZUCxhHAMR4cSsZDbuq/I6FGOM6TWWMI5RTloseyvqvA7DGGN6jSWMY5SVEkdlXRM1Dc1eh2KMMb3CEsYxykqNBWBvufUyjDEDgyWMY5SV4iaMisMeR2KMMb3DEsYxynF7GEXWwzDGDBCWMI5RekI0UeFhNiRljBkwLGEco7AwYVhKDEV2ppQxZoCwhHEcslJjbUjKGDNgWMI4DiPT49lZUoNzo0BjjOnfLGEch1HpCVTVN3OoptHrUIwxJuiCljBE5AkRKRaR9R1sv1pE1rqPJSIyxW/bLhFZJyKrRSQ/WDEer9GZCQDsKKnxOBJjjAm+YPYwngLmdLJ9J3C2qk4Gfgk80mb7Oao6VVXzghTfcRudEQ9AQUmtx5EYY0zwRQTrwKq6WERyO9m+xO/lUiA7WLEEy7DkWGIiw6yHYYwZEEJlDuMrwBt+rxX4t4isFJH5ne0oIvNFJF9E8ktKSoIaZFthYcLI9ARLGMaYASFoPYxAicg5OAnjDL/i01V1n4hkAm+LyGZVXdze/qr6CO5wVl5eXq+frjQ6I561RZW9/bbGGNPrPO1hiMhk4DFgrqqWtpar6j73ZzHwKjDDmwi7NiojgT3lh6lv8nkdijHGBJVnCUNEhgOvANeq6la/8ngRSWx9DlwAtHumVSgYnRGPKuwqtYlvY0z/FrQhKRF5DpgNpItIEXA7EAmgqg8BtwGDgAdFBKDZPSNqMPCqWxYBPKuqbwYrzuM1OsM5tbagpJbxQ5I8jsYYY4InmGdJXdXF9huBG9spLwCmfHKP0DQy3Tm1dkexTXwbY/q3UDlLqs+Kj45gWHKMnSlljOn3LGH0gFEZCeywi/eMMf2cJYweMGFoIlsOVtPY3OJ1KMYYEzSWMHrA5OwUGptb2Hqw2utQjDEmaCxh9IDJ2ckArNtrF/AZY/ovSxg9YHhaHMmxkXbFtzGmX7OE0QNEhMnZyazZU+F1KMYYEzSWMHrItOGpbD5QRVV9k9ehGGNMUFjC6CEzR6XRorByV7nXoRhjTFBYwughJ+ekEhkuLN1Z2nVlY4zpgyxh9JDYqHCmZKewrKDM61CMMSYoLGH0oJmj0li3t5LahmavQzHGmB5nCaMHzRw5CF+LsnK3zWMYY/ofSxg9aPqIVMLDhGU2j2GM6YcsYfSg+OgITspKtnkMY0y/ZAmjh80clcaaogrqGu2WrcaY/sUSRg+bNXIQTT7lo0KbxzDG9C+WMHpYXm4qYQJLd9qwlDGmfwlqwhCRJ0SkWETWd7BdROQ+EdkuImtFZJrftutFZJv7uD6YcfakxJhIJg1LZlmBTXwbY/qXgBKGiHwhkLJ2PAXM6WT7hcBY9zEf+JN77DTgdmAmMAO4XURSA4k1FJwxNp383eUcrKr3OhRjjOkxgfYwfhxg2VFUdTHQ2djMXOBpdSwFUkRkKPBp4G1VLVPVcuBtOk88IeXKvBx8Lcpzywu9DsUYY3pMRGcbReRC4CIgS0Tu89uUBPTE5cxZwB6/10VuWUfl7cU4H6d3wvDhw3sgpOOXmx7PmWPTeW55ITfNHk10RLjXIRljzHHrqoexD8gH6oGVfo8FOL2A4yXtlGkn5Z8sVH1EVfNUNS8jI6MHQuoZXz1zFAerGnhl1V6vQzHGmB7RaQ9DVdcAa0TkWVVtAnDnEnLcoaLjVQTk+L3OxklSRcDsNuULe+D9es2ZY9OZnJ3MI4sLmHdKDiLt5UBjjOk7Ap3DeFtEktzJ6DXAkyLy+x54/wXAde7ZUrOASlXdD7wFXCAiqW6CusAt6zNEhCvycth5qJaCQ7Veh2OMMcet0x6Gn2RVrRKRG4EnVfV2EVnb1U4i8hxOTyFdRIpwznyKBFDVh4B/4cyRbAcOA19yt5WJyC+BFe6hfqGqfe7ChrPGOkNk//v39cRFRfDoddOtp2GM6bMCTRgR7tlLVwA/DfTgqnpVF9sV+GYH254Angj0vULR8EFxDE+LY8kO55qMfZX1ZKXEehyVMcYcm0CHpH6BMyS0Q1VXiMgoYFvwwuo/Zp/w8UT82j0VHkZijDHHJ6CEoap/U9XJqnqT+7pAVS8Lbmj9ww8/fQKvf/sMIsOFNUWVXodjjDHHLNArvbNF5FV3mY+DIvKyiGQHO7j+IMldKmT8kCTW7bUehjGm7wp0SOpJnDOahuFcQPdPt8wEaHJ2MqsLKygqP+x1KMYYc0wCTRgZqvqkqja7j6eA0LlKrg+49tQRhIcJVz26lIrDjV6HY4wx3RZowjgkIteISLj7uAaw5Vi7YfyQJJ768gwOVNbzw7+twTlBzBhj+o5AE8aXcU6pPQDsBy7HvWbCBG7a8FS+d/443tlUzOYD1V6HY4wx3RJowvglcL2qZqhqJk4CuSNoUfVjV+TlECbw2tp9XodijDHdEmjCmOy/dpR71fXJwQmpf0tPiOa00em8tna/DUsZY/qUQBNGmP8NjNw1pQK9Sty0cdn0LHaXHua2f2zg5mdXUd/k8zokY4zpUqBf+vcAS0TkJZxlxq8Afh20qPq5S6dk8fCiAv6ydDcAc04cwiWTh3kclTHGdC7QK72fBi4DDgIlwOdV9S/BDKw/Cw8T7rpsMpdPz2ZwUjQvryyi2dfidVjGGNMp6U/j6Hl5eZqfn+91GN3y/97YxMOLCkiMieDdH5xNZmKM1yEZYwYQEVmpqnmB1A10DsMEydfPGs13zxtLdX0z/1q73+twjDGmQ5YwPJYaH8V3zxvH+CGJvGYJwxgTwixhhIhLJg8lf3c5e8psrSljTGiyhBEiPj8tmzCBZ5YVeh2KMca0yxJGiBiWEsv5EwfzzLLd/OiltZTXNvKP1Xtpaek/JyUYY/q2oF58JyJzgD8C4cBjqnpnm+33Aue4L+OATFVNcbf5gHXutkJVvTSYsYaCm2aPYdvBGl7I38OynaXsKj1MUkwk54zP9Do0Y4wJXg9DRMKBB4ALgYnAVSIy0b+Oqn5PVaeq6lTg/4BX/DbXtW4bCMkCYGpOCv/54WzOGJPOrlJnLmPR1hKPozLGGEcwexgzgO2qWgAgIs8Dc4GNHdS/Crg9iPH0GT+4YBz7K+uIighnsSUMY0yICOYcRhawx+91kVv2CSIyAhgJ/MevOEZE8kVkqYh8tqM3EZH5br38kpL+8eV68vBU3v3BbL4wPZuCQ7Vc/dhSth205dCNMd4KZsKQdso6msGdB7ykqv6r8A13rz78IvAHERnd3o6q+oiq5qlqXkZG/7oJ4GemDGPOpCFs3l/NFx9bxqb9VV6HZIwZwIKZMIqAHL/X2UBHN4GYBzznX6Cq+9yfBcBCBuBy6hmJ0Tx07XSenz+LMIHL/rSEtzYc8DosY8wAFcyEsQIYKyIjRSQKJyksaFtJRE4AUoEP/cpSRSTafZ4OnE7Hcx/93tjBiSy4+QzGDk7ka39ZyXubi70OyRgzAAUtYahqM3Az8BawCXhRVTeIyC9ExP+sp6uA5/XoVRAnAPkisgZ4D7hTVQdswgAYnBTDC/NnMSYzgdsWrLd7aBhjep2tVtvHLNl+iC8+towp2cl86fSRfGbKMMLD2psuMsaYrtlqtf3YaWPSeeia6RSWHea7L6zmoUU7vA7JGDNAWMLog+acOIT8n53P7BMyePT9Amoamr0OyRgzAFjC6KPCw4TvnjeOisNNXPbgEube/1+W7yzzOixjTD9mCaMPm5qTwkPXTKe5pYVtxTXc8+8tXodkjOnHLGH0cXNOHMK7P5jN988fx7KdZXxUWO51SMaYfsoSRj9x5Sk5pCdEc8tLa9m4r4rDjc38+vWNrN9bSU1DMz5bJt0Yc5yCury56T2JMZHce+UUrntiORfd9z6JMRFU1zfzUWEFBYdqueG0XL597livwzTG9GHWw+hHzhybwb+/exZ3fv4kBifFcGJWEvm7yymrbeTfG21JEWPM8bEeRj8zdnAiYwcnMm/GcHYequWc3y0kIkxYv7eKbQerGTEonqgI+zvBGNN99s3Rj41Mj+e+q07mD/OmAnD+vYv537+v9zgqY0xfZQmjn7t0yjAuPHEoo9LjSYyO4OVVRewurfU6LGNMH2RrSQ0QLS3Kvso6zr57Ib4W5WtnjWL6iFSyUmOZNCwZAF+LEiYgYmtTGTNQdGctKZvDGCDCwoTs1DgeuXY6z6/Yw8OLCwAYmhzDO98/m6iIMK54+ENyB8Vz75VTPY7WGBOKbEhqgDl3wmDuvXIq2amxTByaxP7Ker7+15Xc8tJaPiqs4PW1+6mqb/I6TGNMCLIexgCUEB3B2987m+iIMB77bwEPvLeDyromZo5MY9nOMt7ecJDLpmd7HaYxJsTYHIah2deCT5Wo8DDOuOs9slJjeWH+LJvLMGYAsPthmG6JCA8jOiIcEWH+WaNYvrOMN9Y7F/o1Nrfw+tr9LNpa4nGUxhiv2ZCUOcrVM4fz7LJCvvHMKiYNS+JgVQOHahqIDBde+9aZnDAk0esQjTEeCWoPQ0TmiMgWEdkuIre2s/0GESkRkdXu40a/bdeLyDb3cX0w4zQfiwgP4/n5s/jRnPGkxEUybXgKD149jaSYSK54+EP++M42r0M0xngkaHMYIhIObAXOB4qAFcBVqrrRr84NQJ6q3txm3zQgH8gDFFgJTFfVTtfutjmM4Fmzp4LfvrWZD7aX8vb3zmLsYOtpGNMfhMocxgxgu6oWqGoj8DwwN8B9Pw28raplbpJ4G5gTpDhNAKbkpPB/V00jJjKMe/69lcbmFq9DMsb0smAmjCxgj9/rIresrctEZK2IvCQiOd3cFxGZLyL5IpJfUmITs8GUFh/F/LNG8+aGA8x94APeWLefF1YU0p/OtDPGdCyYCaO9czLbfrP8E8hV1cnAO8Cfu7GvU6j6iKrmqWpeRkbGMQdrAvP988fx8LXTKSip4aZnVvGjl9fx6PsFXodljOkFwTxLqgjI8XudDezzr6CqpX4vHwXu8tt3dpt9F/Z4hOaYfHrSEJ65cSZriypZWVjOb/61mYrDTVw8eSj1TS1MG55i13AY0w8FM2GsAMaKyEhgLzAP+KJ/BREZqqr73ZeXApvc528BvxGRVPf1BcCPgxir6aa83DTyctO41jeCuMhwHly4gwcX7gBgxsg0TslN5fvnn0B4mCUOY/qLoCUMVW0WkZtxvvzDgSdUdYOI/ALIV9UFwLdF5FKgGSgDbnD3LRORX+IkHYBfqGpZsGI1xy4yPIy7vzCFq2eNYOuBakpqGnj1o7088N4OBifFcN2puV6HaIzpIbY0iOlxqsq1jy9n9Z4K/nTNNM4ca3NLxoQqW97ceEpE+O3lk/nSkyu49vHljBucQGVdE985dxyr95Tz04snkhwb6XWYxphusoRhgmJYSiyvfOM0Hn2/gA93lFJV18xPXl0HwOFGH/deOZXIcFvKzJi+xIakTK8oKKnhpZVFtCg8tGgHSTERpMVHkZkUwz1fmEJOWpzXIRozIIXKld7GHDEqI4Fb5oznR3NO4PHr87h48jAmZ6ewcV8V339xNfm7ylBVSqobuPbxZXbfcWNCkA1JmV4lIpw7YTDnThgMwEsri/jh39Zw+UMfctslE6lr8vH+tkO8mL+H//n0eI+jNcb4sx6G8dTl07N5/5ZzmH1CBne9uZk/L9kFwJvu/TiMMaHDEobxXE5aHL+9fDJjMhMorm5gRm4aO0pquWPBBhuaMiaE2KS3CRnNvhbW7q1keFoc1z2+nO3FNYSFOetXfXHmCBKibQTVmJ7WnUlvSxgmZB2orOdnf1/PO5sOEiYQHx3BycNTuW7WCM6dkGnrVRnTAyxhmH5DVVm+s4wlO0o5VNPAwi0l7K2oIysllm99agx/XbabL0zP4frTcr0O1Zg+ya70Nv2GiDBz1CBmjhoEQJOvhdfX7ueRxQXc+opzIeCm/RtJiYvkksnDOFhVT2pcFCLOOle2+KExPcd6GKZPqqpv4levbWT2CZnc9+42Nh+oJisllv2VdQxOiqGqrom5J2fxm8+d5HWoxoQ0G5IyA4qvRXlj/X6eW17IiEHxrC6soLKuiYNV9Sy65RyyUmKPqt/Q7CNMxJYmMQZLGF6HYUJAUflhZt+9kDGZCZw2Op2CQzUMT4vj5nPGcMOTK4gMF/729dOIirCkYQY2WxrEDHjZqXH87gtTCBPhhRWF7C49zDPLCjn9rv+wcX8Va4oqufutzV6HaUyfYpPept/67MlZfPbkrCOvNx+o4tevb2JMZgLNPuXR93dSWtvIZdOymTkyjV+9vom6Rh93XT7Zw6iNCV2WMMyAMX5IEn/5ykzAmfdoaPbxzzX7eW3tfmaOTOP9bYcAmJSVRFltI9NHpNrNn4zxY3MYZkArrq7ngnsXU3G4iVsvHM9Di3ZQcbgJgIgw4Z3vn01uerzHURoTPCFzHYaIzAH+iHNP78dU9c42278P3IhzT+8S4Muqutvd5gPWuVULVfXSYMZqBqbMxBj++pWZVNY1cfqYdIYmx7Bydzk3nJbLxff9l+88/xGzRg1i+ohULpg0xOtwjfFU0HoYIhIObAXOB4qAFcBVqrrRr845wDJVPSwiNwGzVfVKd1uNqiZ05z2th2F60iOLd/Dgwh0cbvDR6Gvh8unZDE2OYfWeCtLio/jKGSOZnJ0CcOReHplJMR5HbUz3hEoPYwawXVUL3KCeB+YCRxKGqr7nV38pcE0Q4zGmW+afNZr5Z42m2dfC/3vDWXrdp8qkYUmsLarkH6v3ccHEwdx75VTuenMzzy4r5B83n86kYcleh25MUASzh3E5MEdVb3RfXwvMVNWbO6h/P3BAVX/lvm4GVuMMV92pqn/vYL/5wHyA4cOHT9+9e3ePt8UYgPomH/VNPlLioqiub+KpD3bxh3e3MSQphr0VdQCMH5JIbFQ435g9hvMbS0oqAAATd0lEQVQnDmZ7cTW3/WMD91wxBUEYnBRtiyaakBIqPYz2/le0m51E5BogDzjbr3i4qu4TkVHAf0Rknaru+MQBVR8BHgFnSOr4wzamfTGR4cREhgOQGBPJt84dS1ZqLA8vKuCb54wG4IH3dpAcG8lXn87nljknsGR7KUt2lPKlJ1ew+UA1n5kyjLsvn3zkOMb0JcFMGEVAjt/rbGBf20oich7wU+BsVW1oLVfVfe7PAhFZCJwMfCJhGOOlz0/L5vPTsgFnYcSzx2UyNSeF7724mt++uQWA9IToI2td/XPNPgbFR3H9abn89s3NfP/8cYgIo9LjCbOFEk2IC+aQVATOpPe5wF6cSe8vquoGvzonAy/hDF1t8ytPBQ6raoOIpAMfAnP9J8zbY5PeJlQ0+1p4b0sJB6rqmTUyjZ//cyN3XDqJvy7dzVNLdhEXFc7hRh+ZidEUVzdw1Yzh7C6t5ZvnjOH0Meleh28GkJBZS0pELgL+gHNa7ROq+msR+QWQr6oLROQd4CRgv7tLoapeKiKnAQ8DLTjLl/xBVR/v6v0sYZhQV9/k46FFOygsO8zgpBj+tHDHkeQBMCQphjknDiEtPors1Fj+ll/EtaeO4MITh/CnRTs4Y0z6kTOzjOkJIZMwepslDNOXtLQoi7aWMCYzgR+/so5TRw/i929vJTJcaGhuQRVEICEqgu+cN5Zfvb6JcYMTuGbWCMYPSWLGyDSvm2D6AUsYxvRRByrrSY2PpMmn7CiuIToyjMseXEJto4+E6AhqGpoB5yr0ydnJZCRGc+2sXJ5Ztpvk2Eh+PncS0RHOhPoLKwqJiQxn7tSszt7SDHChcpaUMaabhiQ7F/5FR8CUHGfo6c3vnsUrq/Zy7oRM/vjuNiYMSWRPeR0HKutZvaeCtzYsO7L/ur2V3HbJRJbvLOOet7eSEB3BuRMGkxBt/9XN8bMehjF9WOXhJr71/EdMGpbEyTkp/PTv6ympdk42nJGbxvJdZZw1LoMRaXGcmJXE0ORYpo1IJSYijDARfKp2I6kBzoakjBmgDjc28/ra/aTERXHehEw+++AS1hVVEB0RTl2T70i93EFxjMlM4P1thzhzbDpX5OUctVbW+9tKeHXVXn7z+ZPsmpF+zhKGMQaA8tpGGppbSImLpKS6gfV7K9lysJqHFxVQ1+Tj05MGs66okn2V9Tx49TRyUuPYW1HHT15dR1ltI9+YPZpb5ow/cjxVpb6phdioj5NIS4uyqrCc6SNS7Sr2IGv2taDQo71CSxjGmE4t31nGrkO1XHFKDnWNPj77wAdsOVh9ZHt0RBgz3HuEnDEmHV+LcvYJGTzx351U1DXx7I0zyct1ztL608Id3PXmZp760inMPiHTqyYNCD99dR2FZYeP3NelJ9iktzGmUzNGph05LTc2KpxnvjqT/2wqJiEmgmEpsQxNjiEpJpI739jEO5uKqWvy8WFBKdNHpBJdXc9Nz6zi4pOGsvlAFav3VADw+tr9n0gYxdX1/HzBRr573ljGDk7s9Xb2N5sPVFNUftiz97eEYYwhPSGaK07J+UT5z+eeyM/nwv7KOhZtKeGy6dnsKKnhh39bw9Mf7uLErGQmZ6UQFRHGvzceZO62Q6wqLOdgVT1njk3n+RV7WLilhEZfC49e5/wRW1LdwEX3vc9PLhrP507O7uWW9m2Hahooq21EVT0Z/rMhKWPMMWn2tRDhjqW/t7mYLz21AnAuNoyN/Pjq9QlDk9i0v4qTh6cwc+QgDtU08NLKIsYNTuDN75x1ZA2tlbvLGJmeQFp8lDcN6gMm3fYmtY0+1tx+AcmxkT1yTBuSMsYEXYTfxOvsEzJ49RunUdPQzOTsFGIjw8nfXUZ6QjQZCdF89el8WlR59P0CfC3K0OQYth6sYfxtb5KZGM3ojAQWbS1hVHo8P7jgBKaPSOXvq/cSHxXO56dlE2/XkVDX6KPWTcKlNQ09ljC6wz4FY8xxExFOHp56VNlpoz9eRPGlm04DnCvZ3950kHPHZ/I/L61hSFIsNQ1NrN5Twdypw3hn40G++ewqRKB18OPJD3bxs0smcHJOKmEiHKptYEhSDPHREagqy3aWER4mnJKbRsXhRuqafAxNju21tveWQzVHFvOmrLaRURm9H4MlDGNMrxmSHMO1s0YA8MyNsz6xvby2kV2ltTy7rJC83FSyU+P4zvOr+fJTRw81x0eFMyojgZLqBg5U1QNw2uhBbD5QTU1DM5+eNIRJw5L42lmj+s2pviV+CeNQTaMnMVjCMMaEjNT4KFLjo47qrSy+ZTar91SwtqgSATISo1laUMrBqgbGDU5k2ogUKuuaeHllEaMz4slMjGFpQSn/XLOPl1cWkZEYzQ2n5ZIUG0lKXCTNPmVfRR2fGp951LBaq84mlIur68lM9Oa+7Yeqj+5heMEShjEmpMVFRXDa6PSjhrhab1rl7xuzxxx5rqrc/5/tvLelmG3FNcz/y8pP1E+NiyQrNZbZ4zLZtL+KLQerOSkrmSU7SvnizOGU1zZSVtvIDy44gROGJB653uS2Syby+WlZPLK4gBtOyyUzqfMEoqrc+842Lpg4mBOzjv1+7/69ilK/3kZvsrOkjDH9Wm1DMxv3V9HU3EJxdQOHG32kxEWycEsxWw5Us6aokszEaIYkx7B+byUThyWxfm8VKXHOpHJdo48Ts5JZubuclLhIquqaGDEonp2Hajl11CBumj2ak7KSSY2Pory2kT8t2sHnp2UxfkgSAG9vPMhXn87nlNxU/vb107qMd+GWYhJjIpg+4ujl6+97dxu/f3srMZFhzDtlOHdcOqlHfj92lpQxxrjioyM4JfeT9w656KShADQ2txAVEYaqUn64idS4SCrrmkiOjaS4uoE/vruNjwor+PanxvDlM0bym39t4pVVe7n4pKG8vm4/HxaUEibO6sJ7y+sorm7g5ZVFTBiahAhsL64hPExYsaucF1fsobi6nkVbS5g0LJmbPzWG55cXUlRex0UnDWXSsCRu+usqUuIiWfQ/5xAV8fGQ2aGaBpJiIkiLj6LUoyEp62EYY0w3tSaZ9Xsrqapr4sOCUpbsKCU1LpJLJg/joUU7iAwPIyJcONzg45ufGsPv3tpCYZlzlfakYUlsPlCNAM0tSmJMBNX1zYzNTGBbcQ0A500YTGVdIyLCoPgo8neXkxgTQUpspHN1fjsnDRwLW0vKGGNCTH2Tj2U7yxiRFkduejzbDlbzh3e2MW1EKlfPHM6972zlxRV7OHfCYHYdqmXt3kpOHJZEi0JNQzPpCVFcMnkY728r4d1NxQxPi8OnSrNPSYmL5PVvn3lMcYVMwhCROcAfce7p/Ziq3tlmezTwNDAdKAWuVNVd7rYfA18BfMC3VfWtrt7PEoYxpj9o9rXQohw1JNVq68FqXlixhwNV9USECRFhYSTHRnLbZyYe03uFxByGiIQDDwDnA0XAChFZoKob/ap9BShX1TEiMg+4C7hSRCYC84BJwDDgHREZp6o+jDGmn2vvdN9W4wYn8r+XHFtyOF7BvNXWDGC7qhaoaiPwPDC3TZ25wJ/d5y8B54pzAvRc4HlVbVDVncB293jGGGM8EsyEkQXs8Xtd5Ja1W0dVm4FKYFCA+xpjjOlFwUwY7V0q2XbCpKM6gezrHEBkvojki0h+SUlJN0M0xhgTqGAmjCLAf4H9bGBfR3VEJAJIBsoC3BcAVX1EVfNUNS8jw4PVuIwxZoAIZsJYAYwVkZEiEoUzib2gTZ0FwPXu88uB/6hz2tYCYJ6IRIvISGAssDyIsRpjjOlC0M6SUtVmEbkZeAvntNonVHWDiPwCyFfVBcDjwF9EZDtOz2Keu+8GEXkR2Ag0A9+0M6SMMcZbduGeMcYMYN25DiOYQ1LGGGP6kX7VwxCREmD3Me6eDhzqwXC8ZG0JPf2lHWBtCVXH2pYRqhrQGUP9KmEcDxHJD7RbFuqsLaGnv7QDrC2hqjfaYkNSxhhjAmIJwxhjTEAsYXzsEa8D6EHWltDTX9oB1pZQFfS22ByGMcaYgFgPwxhjTEAsYRhjjAnIgE8YIjJHRLaIyHYRudXreLpLRHaJyDoRWS0i+W5Zmoi8LSLb3J+pXsfZHhF5QkSKRWS9X1m7sYvjPvdzWisi07yL/JM6aMsdIrLX/WxWi8hFftt+7LZli4h82puo2yciOSLynohsEpENIvIdt7zPfTadtKXPfTYiEiMiy0VkjduWn7vlI0Vkmfu5vOCu3Ye7Ft8LbluWiUjucQehqgP2gbPG1Q5gFBAFrAEmeh1XN9uwC0hvU/Zb4Fb3+a3AXV7H2UHsZwHTgPVdxQ5cBLyBs/T9LGCZ1/EH0JY7gB+2U3ei+28tGhjp/hsM97oNfvENBaa5zxOBrW7Mfe6z6aQtfe6zcX+/Ce7zSGCZ+/t+EZjnlj8E3OQ+/wbwkPt8HvDC8cYw0HsYgdwVsC/yv5Phn4HPehhLh1R1Mc6ik/46in0u8LQ6lgIpIjK0dyLtWgdt6UhI31FSVfer6ir3eTWwCecGZn3us+mkLR0J2c/G/f3WuC8j3YcCn8K5Yyl88nNp746mx2ygJ4z+cGc/Bf4tIitFZL5bNlhV94PzHwbI9Cy67uso9r76Wd3sDtM84Tc02Gfa4g5jnIzz12yf/mzatAX64GcjIuEishooBt7G6QFVqHPHUjg63o7uaHrMBnrCCPjOfiHsdFWdBlwIfFNEzvI6oCDpi5/Vn4DRwFRgP3CPW94n2iIiCcDLwHdVtaqzqu2UhVR72mlLn/xsVNWnqlNxbio3A5jQXjX3Z4+3ZaAnjIDv7BeqVHWf+7MYeBXnH9HB1iEB92exdxF2W0ex97nPSlUPuv/BW4BH+XhoI+TbIiKROF+wz6jqK25xn/xs2mtLX/5sAFS1AliIM4eRIs4dS+HoeDu6o+kxG+gJI5C7AoYsEYkXkcTW58AFwHqOvpPh9cA/vInwmHQU+wLgOveMnFlAZevwSKhqM47/OZzPBkL8jpLuOPfjwCZV/b3fpj732XTUlr742YhIhoikuM9jgfNw5mTew7ljKXzyc2nvjqbHzuuZf68fOGd4bMUZC/yp1/F0M/ZROGd0rAE2tMaPM075LrDN/ZnmdawdxP8cznBAE85fQ1/pKHac7vUD7ue0DsjzOv4A2vIXN9a17n/eoX71f+q2ZQtwodfxt2nLGThDF2uB1e7jor742XTSlj732QCTgY/cmNcDt7nlo3CS2nbgb0C0Wx7jvt7ubh91vDHY0iDGGGMCMtCHpIwxxgTIEoYxxpiAWMIwxhgTEEsYxhhjAmIJwxhjTEAsYZiQJyJL3J+5IvLFHj72T9p7r2ARkc+KyG1BOvZPuq7V7WOeJCJP9fRxTd9kp9WaPkNEZuOsMHpJN/YJV1VfJ9trVDWhJ+ILMJ4lwKWqeug4j/OJdgWrLSLyDvBlVS3s6WObvsV6GCbkiUjrCp13Ame69y/4nrsQ290issJdRO5rbv3Z7j0QnsW5OAsR+bu7QOOG1kUaReROINY93jP+7+VetXy3iKwX534jV/ode6GIvCQim0XkmdYVQEXkThHZ6Mbyu3baMQ5oaE0WIvKUiDwkIu+LyFYRucQtD7hdfsdury3XiHP/hNUi8rCIhLe2UUR+Lc59FZaKyGC3/Atue9eIyGK/w/8TZxUEM9B5ffWiPezR1QOocX/OBl7zK58P/Mx9Hg3k49zDYDZQC4z0q9t6VXIszlWyg/yP3c57XYazGmg4MBgoxLm3wmycVT+zcf7g+hDnauI0nCuDW3vtKe2040vAPX6vnwLedI8zFucK8ZjutKu92N3nE3C+6CPd1w8C17nPFfiM+/y3fu+1DshqGz9wOvBPr/8d2MP7R+uCVcb0RRcAk0WkdR2dZJwv3kZguTr3M2j1bRH5nPs8x61X2smxzwCeU2fY56CILAJOAarcYxcBiLPUdC6wFKgHHhOR14HX2jnmUKCkTdmL6iyAt01ECoDx3WxXR84FpgMr3A5QLB8vFtjoF99K4Hz3+QfAUyLyIvDKx4eiGBgWwHuafs4ShunLBPiWqr51VKEz11Hb5vV5wKmqelhEFuL8Jd/VsTvS4PfcB0SoarOIzMD5op4H3IxzYxt/dThf/v7aTiIqAbarCwL8WVV/3M62JlVtfV8f7veAqn5dRGYCFwOrRWSqqpbi/K7qAnxf04/ZHIbpS6pxbrPZ6i3gJnGWr0ZExrmr9raVDJS7yWI8zpLQrZpa929jMXClO5+QgXML1g5XLRXnfgvJqvov4Ls491loaxMwpk3ZF0QkTERG4ywit6Ub7WrLvy3vApeLSKZ7jDQRGdHZziIyWlWXqeptwCE+XuZ7HB+v5moGMOthmL5kLdAsImtwxv//iDMctMqdeC6h/dvRvgl8XUTW4nwhL/Xb9giwVkRWqerVfuWvAqfirASswC2qesBNOO1JBP4hIjE4f91/r506i4F7RET8/sLfAizCmSf5uqrWi8hjAbarraPaIiI/w7kbYxjOKrrfBHZ3sv/dIjLWjf9dt+0A5wCvB/D+pp+z02qN6UUi8kecCeR33OsbXlPVl7rYzTMiEo2T0M7Qj28DagYoG5Iypnf9BojzOohuGA7casnCgPUwjDHGBMh6GMYYYwJiCcMYY0xALGEYY4wJiCUMY4wxAbGEYYwxJiD/HwKUYQ0bX8RsAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters have been trained!\n",
      "Train Accuracy: 0.9990741\n",
      "Test Accuracy: 0.725\n"
     ]
    }
   ],
   "source": [
    "parameters = model(X_train, Y_train, X_test, Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table> \n",
    "    <tr> \n",
    "        <td>\n",
    "            **Train Accuracy**\n",
    "        </td>\n",
    "        <td>\n",
    "        0.999074\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr> \n",
    "        <td>\n",
    "            **Test Accuracy**\n",
    "        </td>\n",
    "        <td>\n",
    "        0.716667\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>\n",
    "\n",
    "Amazing, your algorithm can recognize a sign representing a figure between 0 and 5 with 71.7% accuracy.\n",
    "\n",
    "**Insights**:\n",
    "- Your model seems big enough to fit the training set well. However, given the difference between train and test accuracy, you could try to add L2 or dropout regularization to reduce overfitting. \n",
    "- Think about the session as a block of code to train the model. Each time you run the session on a minibatch, it trains the parameters. In total you have run the session a large number of times (1500 epochs) until you obtained well trained parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.7 - Test with your own image (optional / ungraded exercise)\n",
    "\n",
    "Congratulations on finishing this assignment. You can now take a picture of your hand and see the output of your model. To do that:\n",
    "    1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n",
    "    2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n",
    "    3. Write your image's name in the following code\n",
    "    4. Run the code and check if the algorithm is right!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:11: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0.\n",
      "Use ``matplotlib.pyplot.imread`` instead.\n",
      "  # This is added back by InteractiveShellApp.init_path()\n",
      "D:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:13: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.3.0.\n",
      "Use Pillow instead: ``numpy.array(Image.fromarray(arr).resize())``.\n",
      "  del sys.path[0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your algorithm predicts: y = 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "\n",
    "## START CODE HERE ## (PUT YOUR IMAGE NAME) \n",
    "my_image = \"thumbs_up.jpg\"\n",
    "## END CODE HERE ##\n",
    "\n",
    "# We preprocess your image to fit your algorithm.\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "image = image/255.\n",
    "my_image = scipy.misc.imresize(image, size=(64,64)).reshape((1, 64*64*3)).T\n",
    "my_image_prediction = predict(my_image, parameters)\n",
    "\n",
    "plt.imshow(image)\n",
    "print(\"Your algorithm predicts: y = \" + str(np.squeeze(my_image_prediction)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You indeed deserved a \"thumbs-up\" although as you can see the algorithm seems to classify it incorrectly. The reason is that the training set doesn't contain any \"thumbs-up\", so the model doesn't know how to deal with it! We call that a \"mismatched data distribution\" and it is one of the various of the next course on \"Structuring Machine Learning Projects\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<font color='blue'>\n",
    "**What you should remember**:\n",
    "- Tensorflow is a programming framework used in deep learning\n",
    "- The two main object classes in tensorflow are Tensors and Operators. \n",
    "- When you code in tensorflow you have to take the following steps:\n",
    "    - Create a graph containing Tensors (Variables, Placeholders ...) and Operations (tf.matmul, tf.add, ...)\n",
    "    - Create a session\n",
    "    - Initialize the session\n",
    "    - Run the session to execute the graph\n",
    "- You can execute the graph multiple times as you've seen in model()\n",
    "- The backpropagation and optimization is automatically done when running the session on the \"optimizer\" object."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
